Koneoppimisputki: Omien muuntajien kehittäminen Scikit-learnissa

Koneoppimisputket ovat olennaisia kestävien ja ylläpidettävien koneoppimismallien rakentamisessa. Scikit-learn (sklearn) tarjoaa tehokkaan viitekehyksen näiden putkien luomiseen. Tärkeä osa jokaista hyvää putkea on kyky suorittaa mukautettuja datamuunnoksia. Tässä artikkelissa perehdytään omien muuntajien kehittämiseen scikit-learnissä ja tarjotaan kattava opas datatieteilijöille ja koneoppimisinsinööreille maailmanlaajuisesti.

Mikä on koneoppimisputki?

Koneoppimisputki on sarja datankäsittelykomponentteja, jotka on ketjutettu yhteen. Nämä komponentit sisältävät tyypillisesti:

• Datan puhdistus: Puuttuvien arvojen, poikkeamien ja epäjohdonmukaisuuksien käsittely.
• Piirteidenmuodostus: Uusien piirteiden luominen olemassa olevista mallin suorituskyvyn parantamiseksi.
• Piirteiden valinta: Mallin kannalta olennaisimpien piirteiden valitseminen.
• Mallin koulutus: Koneoppimismallin kouluttaminen esikäsitellyllä datalla.
• Mallin arviointi: Koulutetun mallin suorituskyvyn arviointi.

Putken käyttäminen tarjoaa useita etuja, kuten:

• Toistettavuus: Varmistaa, että samat datankäsittelyvaiheet suoritetaan johdonmukaisesti.
• Modulaarisuus: Datankäsittelyn työnkulun jakaminen uudelleenkäytettäviin komponentteihin.
• Ylläpidettävyys: Datankäsittelyn työnkulun päivittämisen ja ylläpidon helpottaminen.
• Yksinkertaistettu käyttöönotto: Koneoppimismallien käyttöönottoprosessin virtaviivaistaminen.

Miksi käyttää omia muuntajia?

Scikit-learn tarjoaa laajan valikoiman sisäänrakennettuja muuntajia yleisiin datankäsittelytehtäviin. Monissa todellisissa tilanteissa sinun on kuitenkin suoritettava mukautettuja datamuunnoksia, jotka ovat ominaisia juuri sinun datallesi ja ongelmallesi. Tässä omat muuntajat astuvat kuvaan. Omien muuntajien avulla voit kapseloida mukautetun datankäsittelylogiikkasi uudelleenkäytettäviin komponentteihin, jotka voidaan integroida saumattomasti scikit-learn-putkeen.

Kuvittele esimerkiksi, että työskentelet globaalin verkkokauppa-alustan asiakasdatan parissa. Saatat joutua luomaan oman muuntajan, joka muuntaa transaktioiden valuutat yhteiseen valuuttaan (esim. USD) historiallisten valuuttakurssien perusteella. Tai harkitse tilannetta, jossa käsitellään anturidataa eri maissa sijaitsevista IoT-laitteista; voisit rakentaa oman muuntajan normalisoimaan datan paikallisten aikavyöhykkeiden ja mittayksiköiden perusteella.

Oman muuntajan rakentaminen

Luodaksesi oman muuntajan scikit-learnissä, sinun on luotava luokka, joka perii luokista sklearn.base.BaseEstimator ja sklearn.base.TransformerMixin. Luokkasi on toteutettava kaksi metodia:

• fit(self, X, y=None): Tämä metodi oppii kaikki muunnokseen tarvittavat parametrit. Monissa tapauksissa tämä metodi palauttaa yksinkertaisesti self.
• transform(self, X): Tämä metodi soveltaa muunnoksen dataan.

Tässä on perusesimerkki omasta muuntajasta, joka lisää vakioarvon jokaiseen piirteeseen:

            from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np

class AddConstantTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, constant=1):
        self.constant = constant

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        return X + self.constant

            

              
                Copy
              
            
          

Käydään tämä esimerkki läpi:

• Tuo tarvittavat kirjastot: BaseEstimator, TransformerMixin kirjastosta sklearn.base ja numpy numeerisia operaatioita varten.
• Määritä luokka: AddConstantTransformer perii luokista BaseEstimator ja TransformerMixin.
• Konstruktori (__init__): Tämä metodi alustaa muuntajan constant-arvolla (oletusarvo on 1).
• fit-metodi: Tämä metodi palauttaa yksinkertaisesti self, koska tämän muuntajan ei tarvitse oppia mitään parametreja datasta.
• transform-metodi: Tämä metodi lisää constant-arvon jokaiseen elementtiin syötedatassa X.

Käyttöesimerkki

            from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

X = np.array([[1, 2], [3, 4], [5, 6]])

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('add_constant', AddConstantTransformer(constant=2))
])

X_transformed = pipeline.fit_transform(X)

print(X_transformed)

            

              
                Copy
              
            
          

Tämä esimerkki näyttää, kuinka AddConstantTransformer-muunninta käytetään putkessa. Ensin data skaalataan StandardScaler-muuntimella, ja sitten vakio lisätään omalla muuntajallamme.

Edistynyt omien muuntajien kehitys

Tarkastellaan nyt joitakin edistyneempiä skenaarioita ja tekniikoita omien muuntajien rakentamiseen.

Kategoristen piirteiden käsittely

Kategoriset piirteet ovat yleinen datatyyppi koneoppimisessa. Voit luoda omia muuntajia suorittamaan erilaisia operaatioita kategorisille piirteille, kuten one-hot-koodaus, luokkakoodaus tai piirteiden hajautus.

Tässä on esimerkki omasta muuntajasta, joka suorittaa one-hot-koodauksen määritellyille sarakkeille:

            import pandas as pd
from sklearn.preprocessing import OneHotEncoder

class CategoricalEncoder(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None):
        self.categorical_features = categorical_features
        self.encoder = None

    def fit(self, X, y=None):
        if self.categorical_features is None:
            self.categorical_features = X.select_dtypes(include=['object']).columns

        self.encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
        self.encoder.fit(X[self.categorical_features])
        return self

    def transform(self, X):
        X_encoded = self.encoder.transform(X[self.categorical_features])
        X_encoded = pd.DataFrame(X_encoded, index=X.index, columns=self.encoder.get_feature_names_out(self.categorical_features))
        X = X.drop(columns=self.categorical_features)
        X = pd.concat([X, X_encoded], axis=1)
        return X

            

              
                Copy
              
            
          

Tässä esimerkissä:

• Muunnin tunnistaa kategoriset sarakkeet automaattisesti (jos niitä ei ole määritelty).
• Se käyttää scikit-learnin OneHotEncoder-luokkaa koodauksen suorittamiseen.
• Se käsittelee tuntemattomat kategoriat käyttämällä handle_unknown='ignore'.
• Koodatut piirteet liitetään takaisin alkuperäiseen dataframeen.

Puuttuvien arvojen käsittely

Puuttuvat arvot ovat toinen yleinen ongelma koneoppimisen data-aineistoissa. Voit luoda omia muuntajia puuttuvien arvojen paikkaamiseen käyttämällä erilaisia strategioita, kuten keskiarvo-, mediaani- tai moodipaikkaus.

Tässä on esimerkki omasta muuntajasta, joka paikkaa puuttuvat arvot mediaanilla:

            from sklearn.impute import SimpleImputer

class MissingValueImputer(BaseEstimator, TransformerMixin):
    def __init__(self, strategy='median', missing_values=np.nan):
        self.strategy = strategy
        self.missing_values = missing_values
        self.imputer = None

    def fit(self, X, y=None):
        self.imputer = SimpleImputer(strategy=self.strategy, missing_values=self.missing_values)
        self.imputer.fit(X)
        return self

    def transform(self, X):
        return self.imputer.transform(X)

            

              
                Copy
              
            
          

Tämä muunnin käyttää scikit-learnin SimpleImputer-luokkaa paikkauksen suorittamiseen. Se antaa sinun määrittää paikkausstrategian ja arvon, jota käytetään edustamaan puuttuvia arvoja.

Piirteiden skaalaus ja normalisointi

Piirteiden skaalaus ja normalisointi ovat tärkeitä esikäsittelyvaiheita monille koneoppimisalgoritmeille. Voit luoda omia muuntajia toteuttamaan erilaisia skaalaus- ja normalisointitekniikoita.

Vaikka scikit-learn tarjoaa muuntajia kuten StandardScaler ja MinMaxScaler, saatat tarvita mukautetun skaalaimen tietyille datajakaumille. Esimerkiksi, jos sinulla on dataa, jolla on erittäin vino jakauma, PowerTransformer (myös saatavilla scikit-learnissä) saattaa olla sopivampi. Voit kuitenkin kapseloida sen oman muuntajan sisään hallitaksesi sen parametreja ja integroidaksesi sen saumattomasti putkeesi.

            from sklearn.preprocessing import PowerTransformer

class SkewedDataTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, method='yeo-johnson'):
        self.method = method
        self.transformer = None

    def fit(self, X, y=None):
        self.transformer = PowerTransformer(method=self.method)
        self.transformer.fit(X)
        return self

    def transform(self, X):
        return self.transformer.transform(X)

            

              
                Copy
              
            
          

Useiden muunnosten yhdistäminen

Joskus saatat joutua soveltamaan useita muunnoksia samaan dataan. Voit luoda oman muuntajan, joka yhdistää useita muunnoksia yhdeksi vaiheeksi. Tämä voi auttaa yksinkertaistamaan putkeasi ja tekemään siitä luettavamman.

Tässä on esimerkki omasta muuntajasta, joka yhdistää one-hot-koodauksen ja puuttuvien arvojen paikkauksen:

            class CombinedTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None, missing_value_strategy='median'):
        self.categorical_features = categorical_features
        self.missing_value_strategy = missing_value_strategy
        self.categorical_encoder = None
        self.missing_value_imputer = None

    def fit(self, X, y=None):
        self.categorical_encoder = CategoricalEncoder(categorical_features=self.categorical_features)
        self.missing_value_imputer = MissingValueImputer(strategy=self.missing_value_strategy)
        self.categorical_encoder.fit(X)
        self.missing_value_imputer.fit(X)
        return self

    def transform(self, X):
        X = self.categorical_encoder.transform(X)
        X = self.missing_value_imputer.transform(X)
        return X

            

              
                Copy
              
            
          

Tämä muunnin käyttää edellisistä esimerkeistä tuttuja CategoricalEncoder- ja MissingValueImputer-muuntajia suorittaakseen sekä one-hot-koodauksen että puuttuvien arvojen paikkauksen yhdellä kertaa.

Parhaat käytännöt omien muuntajien kehityksessä

Tässä on joitakin parhaita käytäntöjä, joita noudattaa omien muuntajien kehityksessä:

• Pidä se yksinkertaisena: Jokaisen muuntajan tulisi suorittaa yksi, hyvin määritelty tehtävä.
• Tee siitä uudelleenkäytettävä: Suunnittele muuntajasi mahdollisimman yleiskäyttöisiksi, jotta niitä voidaan käyttää uudelleen eri putkissa.
• Käsittele reunatapaukset: Harkitse, miten muuntajasi käsittelee reunatapauksia, kuten puuttuvia arvoja, poikkeamia ja odottamattomia datatyyppejä.
• Kirjoita yksikkötestejä: Kirjoita yksikkötestejä varmistaaksesi, että muuntajasi toimii oikein.
• Dokumentoi koodisi: Dokumentoi koodisi selkeästi, jotta muut ymmärtävät, miten muuntajaasi käytetään.

Tosielämän esimerkkejä

Katsotaanpa joitakin muita tosielämän esimerkkejä omista muuntajista.

Päivämääräpiirteiden muodostus

Aika-sarjadatan kanssa työskenneltäessä on usein hyödyllistä poimia piirteitä päivämääristä, kuten viikonpäivä, kuukausi tai vuosineljännes. Voit luoda oman muuntajan suorittamaan tämän tehtävän.

            class DateFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, date_columns=None):
        self.date_columns = date_columns

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        for col in self.date_columns:
            X[col + '_dayofweek'] = X[col].dt.dayofweek
            X[col + '_month'] = X[col].dt.month
            X[col + '_quarter'] = X[col].dt.quarter
        return X

            

              
                Copy
              
            
          

Tämä muunnin poimii viikonpäivän, kuukauden ja neljänneksen määritellyistä päivämääräsarakkeista.

Tekstipiirteiden muodostus

Tekstidatan kanssa työskenneltäessä on usein hyödyllistä suorittaa piirteidenmuodostusta käyttämällä tekniikoita, kuten TF-IDF tai sanaupotuksia. Voit luoda omia muuntajia suorittamaan näitä tehtäviä. Esimerkiksi, harkitse asiakasarvosteluja useilla kielillä. Saatat tarvita oman muuntajan, joka kääntää arvostelut englanniksi ennen TF-IDF-vektorisoinnin soveltamista.

Huom: Käännöspalvelut vaativat usein API-avaimia ja voivat aiheuttaa kustannuksia. Tämä esimerkki keskittyy oman muuntajan rakenteeseen.

            # Huom: Tämä esimerkki vaatii käännöspalvelun (esim. Google Translate API) ja API-avaimen
# from googletrans import Translator # Esimerkkikirjasto (asenna komennolla pip install googletrans==4.0.0-rc1)

class TextFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, text_column, language='en'):
        self.text_column = text_column
        self.language = language
        # self.translator = Translator() # Luo kääntäjä-instanssi (vaatii määrityksen)

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        # Esimerkki: Käännä englanniksi (korvaa todellisella käännöslogiikalla)
        # X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: self.translator.translate(text, dest=self.language).text)
        # Vale-käännös demonstrointitarkoituksiin
        X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: "Käännetty: " + text)

        # Sovella TF-IDF:ää tai muita tekstin vektorisointitekniikoita tässä
        return X

            

              
                Copy
              
            
          

Geospatiaalisten piirteiden muodostus

Geospatiaalisen datan kanssa työskenneltäessä voit luoda omia muuntajia poimimaan piirteitä, kuten etäisyys lähimpään kaupunkiin, väestötiheys tai maankäyttötyyppi. Esimerkiksi, harkitse kiinteistöjen hintojen analysointia maailmanlaajuisesti. Voisit luoda oman muuntajan, joka hakee tietyn sijainnin keskimääräisen tulotason ulkoisten API-rajapintojen avulla leveys- ja pituuspiirien perusteella.

Integrointi olemassa oleviin kirjastoihin

Omia muuntajia voidaan käyttää muiden Python-kirjastojen toiminnallisuuksien käärimiseen scikit-learn-putkeen. Tämä mahdollistaa muiden kirjastojen tehokkaan hyödyntämisen samalla kun hyödyt putken rakenteesta ja organisoinnista.

Voit esimerkiksi käyttää omaa muunninta integroidaksesi kirjaston poikkeamien havaitsemiseen, aikasarjojen ennustamiseen tai kuvankäsittelyyn koneoppimisputkeesi.

Yhteenveto

Omat muuntajat ovat tehokas työkalu kestävien ja ylläpidettävien koneoppimisputkien rakentamiseen scikit-learnissä. Kapseloimalla mukautetun datankäsittelylogiikkasi uudelleenkäytettäviin komponentteihin voit luoda putkia, jotka ovat helpompia ymmärtää, päivittää ja ottaa käyttöön. Muista noudattaa parhaita käytäntöjä, kirjoittaa yksikkötestejä ja dokumentoida koodisi varmistaaksesi, että omat muuntajasi ovat luotettavia ja ylläpidettäviä. Koneoppimistaitojesi kehittyessä omien muuntajien kehityksen hallitsemisesta tulee korvaamatonta monimutkaisten ja monipuolisten tosielämän ongelmien ratkaisemisessa maailmanlaajuisesti. Kansainvälisen verkkokaupan valuuttamuunnoksista IoT-laitteiden anturidatan käsittelyyn ympäri maailmaa, omat muuntajat antavat sinulle mahdollisuuden räätälöidä putkesi datasi ja sovellustesi erityistarpeisiin.